A ciência de dados abrange um conjunto diversificado de técnicas e ferramentas que permitem a extração de conhecimento e insights valiosos a partir de dados. Python, com sua vasta coleção de bibliotecas, é uma escolha popular para cientistas de dados. Além dos módulos comuns como NumPy, Pandas, Matplotlib e Scikit-learn, existem outros módulos que podem ser utilizados para análises mais avançadas e específicas.
Neste artigo apresento alguns módulos adicionais para ciência de dados utilizando o conjunto de dados House Prices do Kaggle. Esses módulos incluem:
Dask: Para manipulação e análise de dados em grande escala.
XGBoost: Para modelos de gradient boosting.
SHAP: Para interpretar modelos de machine learning.
Plotly: Para visualizações interativas.
TensorFlow: Para deep learning.
# suprimir avisos (warnings)
import warnings
warnings.filterwarnings("ignore")
import dask.dataframe as dd
# URL do conjunto de dados
url = "https://raw.githubusercontent.com/ageron/handson-ml/master/datasets/housing/housing.csv"
# Carregar o conjunto de dados usando Dask
dados_casas_dask = dd.read_csv(url)
# Calcular estatísticas descritivas
descricao_dask = dados_casas_dask.describe()
# executa operações de forma eficiente em grandes conjuntos de dados
descricao_dask_computed = descricao_dask.compute()
# Exibir o resultado das estatísticas descritivas
print(descricao_dask_computed)
longitude latitude housing_median_age total_rooms \
count 20640.000000 20640.000000 20640.000000 20640.000000
mean -119.569704 35.631861 28.639486 2635.763081
std 2.003532 2.135952 12.585558 2181.615252
min -124.350000 32.540000 1.000000 2.000000
25% -121.800000 33.930000 18.000000 1447.750000
50% -118.490000 34.260000 29.000000 2127.000000
75% -118.010000 37.710000 37.000000 3148.000000
max -114.310000 41.950000 52.000000 39320.000000
total_bedrooms population households median_income \
count 20433.000000 20640.000000 20640.000000 20640.000000
mean 537.870553 1425.476744 499.539680 3.870671
std 421.385070 1132.462122 382.329753 1.899822
min 1.000000 3.000000 1.000000 0.499900
25% 296.000000 787.000000 280.000000 2.563400
50% 435.000000 1166.000000 409.000000 3.534800
75% 647.000000 1725.000000 605.000000 4.743250
max 6445.000000 35682.000000 6082.000000 15.000100
median_house_value
count 20640.000000
mean 206855.816909
std 115395.615874
min 14999.000000
25% 119600.000000
50% 179700.000000
75% 264725.000000
max 500001.000000
Utilizamos dask.dataframe para carregar o conjunto de dados. Calculamos estatísticas descritivas com o método describe() e compute() para executar a operação em paralelo.
describe() e compute() no Contexto da Biblioteca Dask
Aqui usamos a função describe() que é uma ferramenta essencial tanto em pandas quanto em dask para gerar um resumo estatístico das colunas de um DataFrame. Ela fornece informações como contagem de valores (count), média (mean), desvio padrão (std), valores mínimos e máximos (min e max), além dos percentis (25%, 50%, 75%).
Quando usamos describe() com dask.dataframe, ela se comporta de maneira semelhante à sua utilização em pandas, mas com uma diferença importante: as operações são executadas de forma distribuída e paralela. Isso torna dask uma escolha mais eficiente para lidar com grandes conjuntos de dados que não cabem na memória, permitindo uma análise rápida e escalável.
import xgboost as xgb
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error
import pandas as pd
# Carregar o conjunto de dados usando pandas
dados_casas = pd.read_csv(url)
# Preparar os dados
X = dados_casas[["total_rooms"]]
y = dados_casas["median_house_value"]
X_treino, X_teste, y_treino, y_teste = train_test_split(X, y, test_size=0.3, random_state=42)
# Treinar um modelo XGBoost
modelo_xgb = xgb.XGBRegressor(objective ='reg:squarederror', n_estimators=100)
modelo_xgb.fit(X_treino, y_treino)
# Fazer previsões
y_pred_xgb = modelo_xgb.predict(X_teste)
# Avaliar o modelo
rmse = mean_squared_error(y_teste, y_pred_xgb, squared=False)
print("RMSE do Modelo XGBoost:", rmse)
RMSE do Modelo XGBoost: 113329.45682157896
Utilizamos xgboost.XGBRegressor para treinar um modelo de regressão.
Avaliamos o modelo utilizando a métrica RMSE (Root Mean Squared Error).
XGBoost é importante na criação de modelos de machine learning usando a técnica de gradient boosting. Aqui no exemplo, treinamos um modelo de regressão com XGBRegressor, usando o mesmo conjunto de dados "House Prices". A eficácia do modelo foi medida pelo RMSE (Root Mean Squared Error), que avalia a diferença entre os valores previstos e os reais.
Nesse exemplo, obtivemos um RMSE de aproximadamente 113329.46, indicando a precisão do modelo em prever os preços das casas.
SHAP (SHapley Additive exPlanations) é uma biblioteca que fornece explicações interpretáveis para os resultados de modelos de machine learning.
import shap
# Criar um objeto Explainer
explainer = shap.Explainer(modelo_xgb, X_treino)
shap_values = explainer(X_teste)
# Visualizar os valores SHAP
shap.summary_plot(shap_values, X_teste)
- Utilizamos shap para interpretar o modelo XGBoost.
- Geramos e visualizamos os valores SHAP que explicam a contribuição de cada variável nas previsões do modelo.
SHAP (SHapley Additive exPlanations) facilita a compreensão de como os modelos de machine learning fazem suas previsões. No nosso exemplo, utilizamos shap para interpretar os resultados do modelo XGBoost. Os valores SHAP indicam a influência de cada variável na previsão do modelo, ajudando a entender a importância de cada característica.
A imagem apresenta um gráfico de dispersão SHAP para a variável total_rooms. Cada ponto no gráfico representa uma previsão feita pelo modelo. A cor dos pontos varia conforme o valor da variável total_rooms (azul para valores baixos e rosa para valores altos). A posição ao longo do eixo x mostra o impacto dessa variável na previsão: pontos à direita do eixo y (positivo) aumentam a previsão do modelo, enquanto pontos à esquerda (negativo) a diminuem.
Este gráfico é útil para visualizar como a variável total_rooms afeta as previsões do modelo XGBoost. De man
1>
import plotly.express as px
# Carregar o conjunto de dados usando pandas
dados_casas = pd.read_csv(url)
# Criar um gráfico de dispersão interativo
fig = px.scatter(dados_casas, x="total_rooms", y="median_house_value", title="Área da Casa vs. Preço")
fig.show()
- Utilizamos plotly.express para criar um gráfico de dispersão interativo.
- Visualizamos a relação entre a área da casa e o preço.
No exemplo, usamos plotly.express para gerar um gráfico de dispersão que mostra a relação entre a área total das casas (total_rooms) e o preço médio das casas (median_house_value).
Cada ponto no gráfico representa uma casa, onde a posição no eixo x indica o número total de cômodos e a posição no eixo y mostra o preço médio da casa. A visualização permit
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
# Carregar o conjunto de dados usando pandas
dados_casas = pd.read_csv(url)
# Preparar os dados
X = dados_casas[["total_rooms"]].values
y = dados_casas["median_house_value"].values
# Definir a arquitetura do modelo
modelo_tf = Sequential([
Dense(10, activation='relu', input_shape=(X.shape[1],)),
Dense(1)
])
# Compilar o modelo
modelo_tf.compile(optimizer='adam', loss='mse')
# Treinar o modelo
modelo_tf.fit(X, y, epochs=10, batch_size=32)
# Fazer previsões
y_pred_tf = modelo_tf.predict(X)
d_tf = modelo_tf.predict(X)
Epoch 1/10 645/645 ━━━━━━━━━━━━━━━━━━━━ 6s 1ms/step - loss: 55275302912.0000 Epoch 2/10 645/645 ━━━━━━━━━━━━━━━━━━━━ 1s 958us/step - loss: 52311486464.0000 Epoch 3/10 645/645 ━━━━━━━━━━━━━━━━━━━━ 1s 965us/step - loss: 46362951680.0000 Epoch 4/10 645/645 ━━━━━━━━━━━━━━━━━━━━ 1s 981us/step - loss: 39216037888.0000 Epoch 5/10 645/645 ━━━━━━━━━━━━━━━━━━━━ 1s 990us/step - loss: 33719570432.0000 Epoch 6/10 645/645 ━━━━━━━━━━━━━━━━━━━━ 1s 1ms/step - loss: 30035683328.0000 Epoch 7/10 645/645 ━━━━━━━━━━━━━━━━━━━━ 1s 986us/step - loss: 28366204928.0000 Epoch 8/10 645/645 ━━━━━━━━━━━━━━━━━━━━ 1s 1ms/step - loss: 26810849280.0000 Epoch 9/10 645/645 ━━━━━━━━━━━━━━━━━━━━ 1s 1ms/step - loss: 27614824448.0000 Epoch 10/10 645/645 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - loss: 27559309312.0000 645/645 ━━━━━━━━━━━━━━━━━━━━ 1s 1ms/step 645/645 ━━━━━━━━━━━━━━━━━━━━ 1s 965us/step
Utilizamos tensorflow.keras para definir e treinar uma rede neural simples.
Fizemos previsões com o modelo treinado.
Neste exemplo, usamos tensorflow.keras para construir e treinar uma rede neural simples com uma camada densa. A rede foi treinada para prever os preços das casas com base na área total. Após o treinamento, usamos o modelo para fazer previsões, demonstrando como o TensorFlow pode ser usado para criar modelos preditivos sofisticados.